/**
 * @license Highcharts JS v8.0.0 (2019-12-10)
 *
 * Client side exporting module
 *
 * (c) 2015-2019 Torstein Honsi / Oystein Moseng
 *
 * License: www.highcharts.com/license
 */
"use strict";
(function (factory) {
  if (typeof module === "object" && module.exports) {
    factory["default"] = factory;
    module.exports = factory;
  } else if (typeof define === "function" && define.amd) {
    define("highcharts/modules/offline-exporting", [
      "highcharts",
      "highcharts/modules/exporting",
    ], function (Highcharts) {
      factory(Highcharts);
      factory.Highcharts = Highcharts;
      return factory;
    });
  } else {
    factory(typeof Highcharts !== "undefined" ? Highcharts : undefined);
  }
})(function (Highcharts) {
  var _modules = Highcharts ? Highcharts._modules : {};
  function _registerModule(obj, path, args, fn) {
    if (!obj.hasOwnProperty(path)) {
      obj[path] = fn.apply(null, args);
    }
  }
  _registerModule(
    _modules,
    "mixins/download-url.js",
    [_modules["parts/Globals.js"]],
    function (Highcharts) {
      /* *
       *
       *  (c) 2015-2019 Oystein Moseng
       *
       *  License: www.highcharts.com/license
       *
       *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
       *
       *  Mixin for downloading content in the browser
       *
       * */
      var win = Highcharts.win,
        nav = win.navigator,
        doc = win.document,
        domurl = win.URL || win.webkitURL || win,
        isEdgeBrowser = /Edge\/\d+/.test(nav.userAgent);
      /**
       * Convert base64 dataURL to Blob if supported, otherwise returns undefined.
       * @private
       * @function Highcharts.dataURLtoBlob
       * @param {string} dataURL
       *        URL to convert
       * @return {string|undefined}
       *         Blob
       */
      Highcharts.dataURLtoBlob = function (dataURL) {
        var parts = dataURL.match(/data:([^;]*)(;base64)?,([0-9A-Za-z+/]+)/);
        if (
          parts &&
          parts.length > 3 &&
          win.atob &&
          win.ArrayBuffer &&
          win.Uint8Array &&
          win.Blob &&
          domurl.createObjectURL
        ) {
          // Try to convert data URL to Blob
          var binStr = win.atob(parts[3]),
            buf = new win.ArrayBuffer(binStr.length),
            binary = new win.Uint8Array(buf),
            blob;
          for (var i = 0; i < binary.length; ++i) {
            binary[i] = binStr.charCodeAt(i);
          }
          blob = new win.Blob([binary], { type: parts[1] });
          return domurl.createObjectURL(blob);
        }
      };
      /**
       * Download a data URL in the browser. Can also take a blob as first param.
       *
       * @private
       * @function Highcharts.downloadURL
       * @param {string|global.URL} dataURL
       *        The dataURL/Blob to download
       * @param {string} filename
       *        The name of the resulting file (w/extension)
       * @return {void}
       */
      Highcharts.downloadURL = function (dataURL, filename) {
        var a = doc.createElement("a"),
          windowRef;
        // IE specific blob implementation
        // Don't use for normal dataURLs
        if (
          typeof dataURL !== "string" &&
          !(dataURL instanceof String) &&
          nav.msSaveOrOpenBlob
        ) {
          nav.msSaveOrOpenBlob(dataURL, filename);
          return;
        }
        // Some browsers have limitations for data URL lengths. Try to convert to
        // Blob or fall back. Edge always needs that blob.
        if (isEdgeBrowser || dataURL.length > 2000000) {
          dataURL = Highcharts.dataURLtoBlob(dataURL);
          if (!dataURL) {
            throw new Error("Failed to convert to blob");
          }
        }
        // Try HTML5 download attr if supported
        if (typeof a.download !== "undefined") {
          a.href = dataURL;
          a.download = filename; // HTML5 download attribute
          doc.body.appendChild(a);
          a.click();
          doc.body.removeChild(a);
        } else {
          // No download attr, just opening data URI
          try {
            windowRef = win.open(dataURL, "chart");
            if (typeof windowRef === "undefined" || windowRef === null) {
              throw new Error("Failed to open window");
            }
          } catch (e) {
            // window.open failed, trying location.href
            win.location.href = dataURL;
          }
        }
      };
    }
  );
  _registerModule(
    _modules,
    "modules/offline-exporting.src.js",
    [_modules["parts/Globals.js"], _modules["parts/Utilities.js"]],
    function (Highcharts, U) {
      /* *
       *
       *  Client side exporting module
       *
       *  (c) 2015 Torstein Honsi / Oystein Moseng
       *
       *  License: www.highcharts.com/license
       *
       *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
       *
       * */
      /* global MSBlobBuilder */
      var extend = U.extend;
      var addEvent = Highcharts.addEvent,
        merge = Highcharts.merge,
        win = Highcharts.win,
        nav = win.navigator,
        doc = win.document,
        domurl = win.URL || win.webkitURL || win,
        isMSBrowser = /Edge\/|Trident\/|MSIE /.test(nav.userAgent),
        // Milliseconds to defer image load event handlers to offset IE bug
        loadEventDeferDelay = isMSBrowser ? 150 : 0;
      // Dummy object so we can reuse our canvas-tools.js without errors
      Highcharts.CanVGRenderer = {};
      /* eslint-disable valid-jsdoc */
      /**
       * Downloads a script and executes a callback when done.
       *
       * @private
       * @function getScript
       * @param {string} scriptLocation
       * @param {Function} callback
       * @return {void}
       */
      function getScript(scriptLocation, callback) {
        var head = doc.getElementsByTagName("head")[0],
          script = doc.createElement("script");
        script.type = "text/javascript";
        script.src = scriptLocation;
        script.onload = callback;
        script.onerror = function () {
          Highcharts.error("Error loading script " + scriptLocation);
        };
        head.appendChild(script);
      }
      /**
       * Get blob URL from SVG code. Falls back to normal data URI.
       *
       * @private
       * @function Highcharts.svgToDataURL
       * @param {string} svg
       * @return {string}
       */
      Highcharts.svgToDataUrl = function (svg) {
        // Webkit and not chrome
        var webKit =
          nav.userAgent.indexOf("WebKit") > -1 &&
          nav.userAgent.indexOf("Chrome") < 0;
        try {
          // Safari requires data URI since it doesn't allow navigation to blob
          // URLs. Firefox has an issue with Blobs and internal references,
          // leading to gradients not working using Blobs (#4550)
          if (!webKit && nav.userAgent.toLowerCase().indexOf("firefox") < 0) {
            return domurl.createObjectURL(
              new win.Blob([svg], {
                type: "image/svg+xml;charset-utf-16",
              })
            );
          }
        } catch (e) {
          // Ignore
        }
        return "data:image/svg+xml;charset=UTF-8," + encodeURIComponent(svg);
      };
      /**
       * Get data:URL from image URL. Pass in callbacks to handle results.
       *
       * @private
       * @function Highcharts.imageToDataUrl
       *
       * @param {string} imageURL
       *
       * @param {string} imageType
       *
       * @param {*} callbackArgs
       *        callbackArgs is used only by callbacks.
       *
       * @param {number} scale
       *
       * @param {Function} successCallback
       *        Receives four arguments: imageURL, imageType, callbackArgs, and scale.
       *
       * @param {Function} taintedCallback
       *        Receives four arguments: imageURL, imageType, callbackArgs, and scale.
       *
       * @param {Function} noCanvasSupportCallback
       *        Receives four arguments: imageURL, imageType, callbackArgs, and scale.
       *
       * @param {Function} failedLoadCallback
       *        Receives four arguments: imageURL, imageType, callbackArgs, and scale.
       *
       * @param {Function} [finallyCallback]
       *        finallyCallback is always called at the end of the process. All
       *        callbacks receive four arguments: imageURL, imageType, callbackArgs,
       *        and scale.
       *
       * @return {void}
       */
      Highcharts.imageToDataUrl = function (
        imageURL,
        imageType,
        callbackArgs,
        scale,
        successCallback,
        taintedCallback,
        noCanvasSupportCallback,
        failedLoadCallback,
        finallyCallback
      ) {
        var img = new win.Image(),
          taintedHandler,
          loadHandler = function () {
            setTimeout(function () {
              var canvas = doc.createElement("canvas"),
                ctx = canvas.getContext && canvas.getContext("2d"),
                dataURL;
              try {
                if (!ctx) {
                  noCanvasSupportCallback(
                    imageURL,
                    imageType,
                    callbackArgs,
                    scale
                  );
                } else {
                  canvas.height = img.height * scale;
                  canvas.width = img.width * scale;
                  ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
                  // Now we try to get the contents of the canvas.
                  try {
                    dataURL = canvas.toDataURL(imageType);
                    successCallback(dataURL, imageType, callbackArgs, scale);
                  } catch (e) {
                    taintedHandler(imageURL, imageType, callbackArgs, scale);
                  }
                }
              } finally {
                if (finallyCallback) {
                  finallyCallback(imageURL, imageType, callbackArgs, scale);
                }
              }
              // IE bug where image is not always ready despite calling load
              // event.
            }, loadEventDeferDelay);
          },
          // Image load failed (e.g. invalid URL)
          errorHandler = function () {
            failedLoadCallback(imageURL, imageType, callbackArgs, scale);
            if (finallyCallback) {
              finallyCallback(imageURL, imageType, callbackArgs, scale);
            }
          };
        // This is called on load if the image drawing to canvas failed with a
        // security error. We retry the drawing with crossOrigin set to Anonymous.
        taintedHandler = function () {
          img = new win.Image();
          taintedHandler = taintedCallback;
          // Must be set prior to loading image source
          img.crossOrigin = "Anonymous";
          img.onload = loadHandler;
          img.onerror = errorHandler;
          img.src = imageURL;
        };
        img.onload = loadHandler;
        img.onerror = errorHandler;
        img.src = imageURL;
      };
      /* eslint-enable valid-jsdoc */
      /**
       * Get data URL to an image of an SVG and call download on it options object:
       *
       * - **filename:** Name of resulting downloaded file without extension. Default
       *   is `chart`.
       *
       * - **type:** File type of resulting download. Default is `image/png`.
       *
       * - **scale:** Scaling factor of downloaded image compared to source. Default
       *   is `1`.
       *
       * - **libURL:** URL pointing to location of dependency scripts to download on
       *   demand. Default is the exporting.libURL option of the global Highcharts
       *   options pointing to our server.
       *
       * @function Highcharts.downloadSVGLocal
       *
       * @param {string} svg
       * The generated SVG
       *
       * @param {Highcharts.ExportingOptions} options
       * The exporting options
       *
       * @param {Function} failCallback
       * The callback function in case of errors
       *
       * @param {Function} [successCallback]
       * The callback function in case of success
       *
       * @return {void}
       */
      Highcharts.downloadSVGLocal = function (
        svg,
        options,
        failCallback,
        successCallback
      ) {
        var svgurl,
          blob,
          objectURLRevoke = true,
          finallyHandler,
          libURL = options.libURL || Highcharts.getOptions().exporting.libURL,
          dummySVGContainer = doc.createElement("div"),
          imageType = options.type || "image/png",
          filename =
            (options.filename || "chart") +
            "." +
            (imageType === "image/svg+xml" ? "svg" : imageType.split("/")[1]),
          scale = options.scale || 1;
        // Allow libURL to end with or without fordward slash
        libURL = libURL.slice(-1) !== "/" ? libURL + "/" : libURL;
        /* eslint-disable valid-jsdoc */
        /**
         * @private
         */
        function svgToPdf(svgElement, margin) {
          var width = svgElement.width.baseVal.value + 2 * margin,
            height = svgElement.height.baseVal.value + 2 * margin,
            pdf = new win.jsPDF("l", "pt", [width, height]); // eslint-disable-line new-cap
          // Workaround for #7090, hidden elements were drawn anyway. It comes
          // down to https://github.com/yWorks/svg2pdf.js/issues/28. Check this
          // later.
          [].forEach.call(
            svgElement.querySelectorAll('*[visibility="hidden"]'),
            function (node) {
              node.parentNode.removeChild(node);
            }
          );
          win.svg2pdf(svgElement, pdf, { removeInvalid: true });
          return pdf.output("datauristring");
        }
        /**
         * @private
         * @return {void}
         */
        function downloadPDF() {
          dummySVGContainer.innerHTML = svg;
          var textElements = dummySVGContainer.getElementsByTagName("text"),
            titleElements,
            svgData,
            // Copy style property to element from parents if it's not there.
            // Searches up hierarchy until it finds prop, or hits the chart
            // container.
            setStylePropertyFromParents = function (el, propName) {
              var curParent = el;
              while (curParent && curParent !== dummySVGContainer) {
                if (curParent.style[propName]) {
                  el.style[propName] = curParent.style[propName];
                  break;
                }
                curParent = curParent.parentNode;
              }
            };
          // Workaround for the text styling. Making sure it does pick up settings
          // for parent elements.
          [].forEach.call(textElements, function (el) {
            // Workaround for the text styling. making sure it does pick up the
            // root element
            ["font-family", "font-size"].forEach(function (property) {
              setStylePropertyFromParents(el, property);
            });
            el.style["font-family"] =
              el.style["font-family"] &&
              el.style["font-family"].split(" ").splice(-1);
            // Workaround for plotband with width, removing title from text
            // nodes
            titleElements = el.getElementsByTagName("title");
            [].forEach.call(titleElements, function (titleElement) {
              el.removeChild(titleElement);
            });
          });
          svgData = svgToPdf(dummySVGContainer.firstChild, 0);
          try {
            Highcharts.downloadURL(svgData, filename);
            if (successCallback) {
              successCallback();
            }
          } catch (e) {
            failCallback(e);
          }
        }
        /* eslint-enable valid-jsdoc */
        // Initiate download depending on file type
        if (imageType === "image/svg+xml") {
          // SVG download. In this case, we want to use Microsoft specific Blob if
          // available
          try {
            if (typeof nav.msSaveOrOpenBlob !== "undefined") {
              blob = new MSBlobBuilder();
              blob.append(svg);
              svgurl = blob.getBlob("image/svg+xml");
            } else {
              svgurl = Highcharts.svgToDataUrl(svg);
            }
            Highcharts.downloadURL(svgurl, filename);
            if (successCallback) {
              successCallback();
            }
          } catch (e) {
            failCallback(e);
          }
        } else if (imageType === "application/pdf") {
          if (win.jsPDF && win.svg2pdf) {
            downloadPDF();
          } else {
            // Must load pdf libraries first. // Don't destroy the object URL
            // yet since we are doing things asynchronously. A cleaner solution
            // would be nice, but this will do for now.
            objectURLRevoke = true;
            getScript(libURL + "jspdf.js", function () {
              getScript(libURL + "svg2pdf.js", function () {
                downloadPDF();
              });
            });
          }
        } else {
          // PNG/JPEG download - create bitmap from SVG
          svgurl = Highcharts.svgToDataUrl(svg);
          finallyHandler = function () {
            try {
              domurl.revokeObjectURL(svgurl);
            } catch (e) {
              // Ignore
            }
          };
          // First, try to get PNG by rendering on canvas
          Highcharts.imageToDataUrl(
            svgurl,
            imageType,
            {},
            scale,
            function (imageURL) {
              // Success
              try {
                Highcharts.downloadURL(imageURL, filename);
                if (successCallback) {
                  successCallback();
                }
              } catch (e) {
                failCallback(e);
              }
            },
            function () {
              // Failed due to tainted canvas
              // Create new and untainted canvas
              var canvas = doc.createElement("canvas"),
                ctx = canvas.getContext("2d"),
                imageWidth =
                  svg.match(/^<svg[^>]*width\s*=\s*\"?(\d+)\"?[^>]*>/)[1] *
                  scale,
                imageHeight =
                  svg.match(/^<svg[^>]*height\s*=\s*\"?(\d+)\"?[^>]*>/)[1] *
                  scale,
                downloadWithCanVG = function () {
                  ctx.drawSvg(svg, 0, 0, imageWidth, imageHeight);
                  try {
                    Highcharts.downloadURL(
                      nav.msSaveOrOpenBlob
                        ? canvas.msToBlob()
                        : canvas.toDataURL(imageType),
                      filename
                    );
                    if (successCallback) {
                      successCallback();
                    }
                  } catch (e) {
                    failCallback(e);
                  } finally {
                    finallyHandler();
                  }
                };
              canvas.width = imageWidth;
              canvas.height = imageHeight;
              if (win.canvg) {
                // Use preloaded canvg
                downloadWithCanVG();
              } else {
                // Must load canVG first. // Don't destroy the object URL
                // yet since we are doing things asynchronously. A cleaner
                // solution would be nice, but this will do for now.
                objectURLRevoke = true;
                // Get RGBColor.js first, then canvg
                getScript(libURL + "rgbcolor.js", function () {
                  getScript(libURL + "canvg.js", function () {
                    downloadWithCanVG();
                  });
                });
              }
            },
            // No canvas support
            failCallback,
            // Failed to load image
            failCallback,
            // Finally
            function () {
              if (objectURLRevoke) {
                finallyHandler();
              }
            }
          );
        }
      };
      /* eslint-disable valid-jsdoc */
      /**
       * Get SVG of chart prepared for client side export. This converts embedded
       * images in the SVG to data URIs. It requires the regular exporting module. The
       * options and chartOptions arguments are passed to the getSVGForExport
       * function.
       *
       * @private
       * @function Highcharts.Chart#getSVGForLocalExport
       * @param {Highcharts.ExportingOptions} options
       * @param {Highcharts.Options} chartOptions
       * @param {Function} failCallback
       * @param {Function} successCallback
       * @return {void}
       */
      Highcharts.Chart.prototype.getSVGForLocalExport = function (
        options,
        chartOptions,
        failCallback,
        successCallback
      ) {
        var chart = this,
          images,
          imagesEmbedded = 0,
          chartCopyContainer,
          chartCopyOptions,
          el,
          i,
          l,
          href,
          // After grabbing the SVG of the chart's copy container we need to do
          // sanitation on the SVG
          sanitize = function (svg) {
            return chart.sanitizeSVG(svg, chartCopyOptions);
          },
          // When done with last image we have our SVG
          checkDone = function () {
            if (imagesEmbedded === images.length) {
              successCallback(sanitize(chartCopyContainer.innerHTML));
            }
          },
          // Success handler, we converted image to base64!
          embeddedSuccess = function (imageURL, imageType, callbackArgs) {
            ++imagesEmbedded;
            // Change image href in chart copy
            callbackArgs.imageElement.setAttributeNS(
              "http://www.w3.org/1999/xlink",
              "href",
              imageURL
            );
            checkDone();
          };
        // Hook into getSVG to get a copy of the chart copy's container (#8273)
        chart.unbindGetSVG = addEvent(chart, "getSVG", function (e) {
          chartCopyOptions = e.chartCopy.options;
          chartCopyContainer = e.chartCopy.container.cloneNode(true);
        });
        // Trigger hook to get chart copy
        chart.getSVGForExport(options, chartOptions);
        images = chartCopyContainer.getElementsByTagName("image");
        try {
          // If there are no images to embed, the SVG is okay now.
          if (!images.length) {
            // Use SVG of chart copy
            successCallback(sanitize(chartCopyContainer.innerHTML));
            return;
          }
          // Go through the images we want to embed
          for (i = 0, l = images.length; i < l; ++i) {
            el = images[i];
            href = el.getAttributeNS("http://www.w3.org/1999/xlink", "href");
            if (href) {
              Highcharts.imageToDataUrl(
                href,
                "image/png",
                { imageElement: el },
                options.scale,
                embeddedSuccess,
                // Tainted canvas
                failCallback,
                // No canvas support
                failCallback,
                // Failed to load source
                failCallback
              );
              // Hidden, boosted series have blank href (#10243)
            } else {
              ++imagesEmbedded;
              el.parentNode.removeChild(el);
              checkDone();
            }
          }
        } catch (e) {
          failCallback(e);
        }
        // Clean up
        chart.unbindGetSVG();
      };
      /* eslint-enable valid-jsdoc */
      /**
       * Exporting and offline-exporting modules required. Export a chart to an image
       * locally in the user's browser.
       *
       * @function Highcharts.Chart#exportChartLocal
       *
       * @param  {Highcharts.ExportingOptions} [exportingOptions]
       *         Exporting options, the same as in
       *         {@link Highcharts.Chart#exportChart}.
       *
       * @param  {Highcharts.Options} [chartOptions]
       *         Additional chart options for the exported chart. For example a
       *         different background color can be added here, or `dataLabels`
       *         for export only.
       *
       * @return {void}
       *
       * @requires modules/exporting
       */
      Highcharts.Chart.prototype.exportChartLocal = function (
        exportingOptions,
        chartOptions
      ) {
        var chart = this,
          options = Highcharts.merge(chart.options.exporting, exportingOptions),
          fallbackToExportServer = function (err) {
            if (options.fallbackToExportServer === false) {
              if (options.error) {
                options.error(options, err);
              } else {
                Highcharts.error(28, true); // Fallback disabled
              }
            } else {
              chart.exportChart(options);
            }
          },
          svgSuccess = function (svg) {
            // If SVG contains foreignObjects all exports except SVG will fail,
            // as both CanVG and svg2pdf choke on this. Gracefully fall back.
            if (
              svg.indexOf("<foreignObject") > -1 &&
              options.type !== "image/svg+xml"
            ) {
              fallbackToExportServer(
                "Image type not supported" + "for charts with embedded HTML"
              );
            } else {
              Highcharts.downloadSVGLocal(
                svg,
                extend({ filename: chart.getFilename() }, options),
                fallbackToExportServer
              );
            }
          },
          // Return true if the SVG contains images with external data. With the
          // boost module there are `image` elements with encoded PNGs, these are
          // supported by svg2pdf and should pass (#10243).
          hasExternalImages = function () {
            return [].some.call(
              chart.container.getElementsByTagName("image"),
              function (image) {
                var href = image.getAttribute("href");
                return href !== "" && href.indexOf("data:") !== 0;
              }
            );
          };
        // If we are on IE and in styled mode, add a whitelist to the renderer for
        // inline styles that we want to pass through. There are so many styles by
        // default in IE that we don't want to blacklist them all.
        if (isMSBrowser && chart.styledMode) {
          Highcharts.SVGRenderer.prototype.inlineWhitelist = [
            /^blockSize/,
            /^border/,
            /^caretColor/,
            /^color/,
            /^columnRule/,
            /^columnRuleColor/,
            /^cssFloat/,
            /^cursor/,
            /^fill$/,
            /^fillOpacity/,
            /^font/,
            /^inlineSize/,
            /^length/,
            /^lineHeight/,
            /^opacity/,
            /^outline/,
            /^parentRule/,
            /^rx$/,
            /^ry$/,
            /^stroke/,
            /^textAlign/,
            /^textAnchor/,
            /^textDecoration/,
            /^transform/,
            /^vectorEffect/,
            /^visibility/,
            /^x$/,
            /^y$/,
          ];
        }
        // Always fall back on:
        // - MS browsers: Embedded images JPEG/PNG, or any PDF
        // - Embedded images and PDF
        if (
          (isMSBrowser &&
            (options.type === "application/pdf" ||
              (chart.container.getElementsByTagName("image").length &&
                options.type !== "image/svg+xml"))) ||
          (options.type === "application/pdf" && hasExternalImages())
        ) {
          fallbackToExportServer(
            "Image type not supported for this chart/browser."
          );
          return;
        }
        chart.getSVGForLocalExport(
          options,
          chartOptions,
          fallbackToExportServer,
          svgSuccess
        );
      };
      // Extend the default options to use the local exporter logic
      merge(true, Highcharts.getOptions().exporting, {
        libURL: "https://code.highcharts.com/8.0.0/lib/",
        // When offline-exporting is loaded, redefine the menu item definitions
        // related to download.
        menuItemDefinitions: {
          downloadPNG: {
            textKey: "downloadPNG",
            onclick: function () {
              this.exportChartLocal();
            },
          },
          downloadJPEG: {
            textKey: "downloadJPEG",
            onclick: function () {
              this.exportChartLocal({
                type: "image/jpeg",
              });
            },
          },
          downloadSVG: {
            textKey: "downloadSVG",
            onclick: function () {
              this.exportChartLocal({
                type: "image/svg+xml",
              });
            },
          },
          downloadPDF: {
            textKey: "downloadPDF",
            onclick: function () {
              this.exportChartLocal({
                type: "application/pdf",
              });
            },
          },
        },
      });
    }
  );
  _registerModule(
    _modules,
    "masters/modules/offline-exporting.src.js",
    [],
    function () {}
  );
});
